#!/usr/bin/env node

/**
 * 时间管理功能完整测试套件
 * 测试P0功能：时分秒支持 + 自定义提醒间隔
 */

// 使用Node.js内置的fetch API（Node 18+）

const BASE_URL = 'http://localhost:5000/api';
let authToken = '';

// 测试配置
const TEST_CONFIG = {
  email: 'admin@aide.com',
  password: 'admin123456',
  baseUrl: BASE_URL
};

// 测试结果收集器
const testResults = {
  total: 0,
  passed: 0,
  failed: 0,
  details: []
};

function logTest(testName, passed, details = '') {
  testResults.total++;
  if (passed) {
    testResults.passed++;
    console.log(`✅ ${testName}`);
  } else {
    testResults.failed++;
    console.log(`❌ ${testName}: ${details}`);
  }
  testResults.details.push({
    name: testName,
    passed,
    details,
    timestamp: new Date().toISOString()
  });
}

// API请求封装
async function apiRequest(method, endpoint, data = null) {
  try {
    const headers = {
      'Content-Type': 'application/json'
    };
    
    if (authToken) {
      headers['Authorization'] = `Bearer ${authToken}`;
    }
    
    const config = {
      method,
      headers
    };
    
    if (data && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
      config.body = JSON.stringify(data);
    }
    
    const response = await fetch(`${BASE_URL}${endpoint}`, config);
    const responseData = await response.json();
    
    if (response.ok) {
      return { success: true, data: responseData };
    } else {
      return { 
        success: false, 
        error: responseData.error || `HTTP ${response.status}`,
        status: response.status 
      };
    }
  } catch (error) {
    return { 
      success: false, 
      error: error.message,
      status: 0
    };
  }
}

// 1. 登录测试
async function testLogin() {
  console.log('\n🔐 测试用户登录...');
  
  const result = await apiRequest('POST', '/auth/login/email', {
    email: TEST_CONFIG.email,
    password: TEST_CONFIG.password
  });
  
  if (result.success && result.data.token) {
    authToken = result.data.token;
    logTest('用户登录', true);
    return true;
  } else {
    logTest('用户登录', false, result.error);
    return false;
  }
}

// 2. 测试时分秒支持
async function testTimeSupport() {
  console.log('\n⏰ 测试时分秒支持功能...');
  
  const testCases = [
    {
      name: '创建带时分秒的任务',
      task: {
        title: '测试时分秒任务',
        description: '测试时间精度',
        dueDate: '2024-12-25T15:30:00.000Z', // 完整时间戳
        reminderMinutes: 30,
        priority: 'P1',
        category: 'work',
        notes: '测试备注'
      }
    },
    {
      name: '创建只有日期的任务',
      task: {
        title: '测试日期任务',
        description: '只有日期',
        dueDate: '2024-12-25',
        reminderMinutes: 15,
        priority: 'P2',
        category: 'personal'
      }
    }
  ];
  
  const createdTasks = [];
  
  for (const testCase of testCases) {
    const result = await apiRequest('POST', '/tasks', testCase.task);
    
    if (result.success && result.data.id) {
      createdTasks.push(result.data.id);
      logTest(testCase.name, true);
      
      // 验证任务是否正确保存
      const getResult = await apiRequest('GET', `/tasks/${result.data.id}`);
      if (getResult.success) {
        const savedTask = getResult.data;
        const hasCorrectDueDate = savedTask.dueDate === testCase.task.dueDate;
        const hasCorrectReminder = savedTask.reminder_minutes == testCase.task.reminderMinutes;
        
        logTest(`${testCase.name} - 数据验证`, 
          hasCorrectDueDate && hasCorrectReminder,
          `dueDate: ${savedTask.dueDate}, reminder: ${savedTask.reminder_minutes}`
        );
      }
    } else {
      logTest(testCase.name, false, result.error);
    }
  }
  
  return createdTasks;
}

// 3. 测试自定义提醒间隔
async function testCustomReminderIntervals() {
  console.log('\n🔔 测试自定义提醒间隔功能...');
  
  const reminderIntervals = [5, 15, 30, 60, 120, 1440]; // 5分钟到1天
  const createdTasks = [];
  
  for (const minutes of reminderIntervals) {
    const task = {
      title: `测试${minutes}分钟提醒任务`,
      description: `提前${minutes}分钟提醒`,
      dueDate: new Date(Date.now() + 2 * 60 * 60 * 1000).toISOString(), // 2小时后
      reminderMinutes: minutes,
      priority: 'P2',
      category: 'work'
    };
    
    const result = await apiRequest('POST', '/tasks', task);
    
    if (result.success && result.data.id) {
      createdTasks.push(result.data.id);
      logTest(`创建${minutes}分钟提醒任务`, true);
    } else {
      logTest(`创建${minutes}分钟提醒任务`, false, result.error);
    }
  }
  
  return createdTasks;
}

// 4. 测试提醒检查API
async function testReminderCheckAPI() {
  console.log('\n🔍 测试提醒检查API...');
  
  // 创建一个即将到期的任务（1分钟后）
  const urgentTask = {
    title: '紧急测试任务',
    description: '用于测试提醒功能',
    dueDate: new Date(Date.now() + 2 * 60 * 1000).toISOString(), // 2分钟后
    reminderMinutes: 5, // 5分钟前提醒（已经过了提醒时间）
    priority: 'P0',
    category: 'work'
  };
  
  const createResult = await apiRequest('POST', '/tasks', urgentTask);
  
  if (createResult.success) {
    logTest('创建紧急测试任务', true);
    
    // 测试提醒检查API
    const reminderResult = await apiRequest('POST', '/notifications/check-reminders');
    
    if (reminderResult.success) {
      logTest('提醒检查API调用', true);
      
      // 检查是否包含我们的紧急任务
      const reminders = reminderResult.data;
      const hasUrgentTask = reminders.some(r => r.title === urgentTask.title);
      
      logTest('紧急任务出现在提醒列表', hasUrgentTask, 
        `找到${reminders.length}个提醒任务`);
    } else {
      logTest('提醒检查API调用', false, reminderResult.error);
    }
    
    return createResult.data.id;
  } else {
    logTest('创建紧急测试任务', false, createResult.error);
    return null;
  }
}

// 5. 测试AI智能解析时间
async function testAITimeParsing() {
  console.log('\n🤖 测试AI智能解析时间功能...');
  
  const testInputs = [
    '明天下午3点开会',
    '后天上午9点半晨练',
    '下周一15:30项目评审',
    '今天晚上8点看电影'
  ];
  
  for (const input of testInputs) {
    const result = await apiRequest('POST', '/ai/smart-parse', { text: input });
    
    if (result.success) {
      const parsed = result.data.result;
      const hasDate = !!parsed.dueDate;
      const hasTimeInfo = parsed.notes && parsed.notes.includes('时间');
      
      logTest(`AI解析"${input}"`, hasDate, 
        `解析结果: ${parsed.dueDate}, 备注: ${parsed.notes}`);
    } else {
      logTest(`AI解析"${input}"`, false, result.error);
    }
  }
}

// 6. 测试数据库字段完整性
async function testDatabaseFields() {
  console.log('\n🗄️ 测试数据库字段完整性...');
  
  // 获取所有任务，检查字段
  const result = await apiRequest('GET', '/tasks');
  
  if (result.success && result.data.length > 0) {
    const task = result.data[0];
    
    const hasReminderMinutes = task.hasOwnProperty('reminder_minutes');
    const hasDueDate = task.hasOwnProperty('dueDate');
    const hasBasicFields = task.hasOwnProperty('title') && task.hasOwnProperty('priority');
    
    logTest('任务包含reminder_minutes字段', hasReminderMinutes);
    logTest('任务包含dueDate字段', hasDueDate);
    logTest('任务包含基础字段', hasBasicFields);
    
    // 检查字段类型
    if (hasReminderMinutes) {
      const isNumber = typeof task.reminder_minutes === 'number';
      logTest('reminder_minutes字段类型正确', isNumber, 
        `类型: ${typeof task.reminder_minutes}, 值: ${task.reminder_minutes}`);
    }
  } else {
    logTest('获取任务数据', false, '无法获取任务数据进行字段检查');
  }
}

// 7. 清理测试数据
async function cleanupTestData(taskIds) {
  console.log('\n🧹 清理测试数据...');
  
  let cleanedCount = 0;
  
  for (const taskId of taskIds) {
    if (taskId) {
      const result = await apiRequest('DELETE', `/tasks/${taskId}`);
      if (result.success) {
        cleanedCount++;
      }
    }
  }
  
  logTest('清理测试数据', true, `清理了${cleanedCount}个测试任务`);
}

// 生成测试报告
function generateTestReport() {
  console.log('\n' + '='.repeat(80));
  console.log('📊 时间管理功能测试报告');
  console.log('='.repeat(80));
  
  console.log(`\n📈 测试统计:`);
  console.log(`   总测试数: ${testResults.total}`);
  console.log(`   通过数: ${testResults.passed} (${Math.round(testResults.passed/testResults.total*100)}%)`);
  console.log(`   失败数: ${testResults.failed} (${Math.round(testResults.failed/testResults.total*100)}%)`);
  
  const status = testResults.failed === 0 ? '🟢 通过' : '🔴 失败';
  console.log(`\n🎯 整体状态: ${status}`);
  
  if (testResults.failed > 0) {
    console.log('\n❌ 失败的测试:');
    testResults.details
      .filter(test => !test.passed)
      .forEach(test => {
        console.log(`   - ${test.name}: ${test.details}`);
      });
  }
  
  console.log('\n✅ 功能验证结果:');
  console.log('   🔸 P0.1 时分秒支持: ', testResults.details.some(t => t.name.includes('时分秒') && t.passed) ? '✅ 通过' : '❌ 失败');
  console.log('   🔸 P0.2 自定义提醒间隔: ', testResults.details.some(t => t.name.includes('提醒') && t.passed) ? '✅ 通过' : '❌ 失败');
  console.log('   🔸 数据库字段完整性: ', testResults.details.some(t => t.name.includes('字段') && t.passed) ? '✅ 通过' : '❌ 失败');
  console.log('   🔸 API接口稳定性: ', testResults.details.some(t => t.name.includes('API') && t.passed) ? '✅ 通过' : '❌ 失败');
  
  const isReadyForProduction = testResults.failed === 0 && testResults.passed >= 10;
  console.log(`\n🚀 上线评估: ${isReadyForProduction ? '✅ 达到上线标准' : '❌ 需要修复问题'}`);
  
  if (isReadyForProduction) {
    console.log('\n🎉 恭喜！时间管理功能已达到上线标准！');
    console.log('   - 所有核心功能正常工作');
    console.log('   - API接口稳定可靠');
    console.log('   - 数据库结构完整');
    console.log('   - 用户体验良好');
  } else {
    console.log('\n⚠️ 建议在上线前解决以下问题:');
    testResults.details
      .filter(test => !test.passed)
      .forEach(test => console.log(`   - ${test.name}`));
  }
  
  console.log('\n' + '='.repeat(80));
  
  return isReadyForProduction;
}

// 主测试流程
async function runTests() {
  console.log('🚀 开始时间管理功能完整测试...');
  console.log(`📍 测试目标: ${BASE_URL}`);
  console.log(`👤 测试账号: ${TEST_CONFIG.email}`);
  
  const allTaskIds = [];
  
  try {
    // 1. 登录
    const loginSuccess = await testLogin();
    if (!loginSuccess) {
      console.log('❌ 登录失败，终止测试');
      return false;
    }
    
    // 2. 测试时分秒支持
    const timeTestTasks = await testTimeSupport();
    allTaskIds.push(...timeTestTasks);
    
    // 3. 测试自定义提醒间隔
    const reminderTestTasks = await testCustomReminderIntervals();
    allTaskIds.push(...reminderTestTasks);
    
    // 4. 测试提醒检查API
    const urgentTaskId = await testReminderCheckAPI();
    if (urgentTaskId) allTaskIds.push(urgentTaskId);
    
    // 5. 测试AI智能解析
    await testAITimeParsing();
    
    // 6. 测试数据库字段
    await testDatabaseFields();
    
    // 7. 清理测试数据
    await cleanupTestData(allTaskIds);
    
  } catch (error) {
    console.error('💥 测试过程中发生错误:', error.message);
    logTest('测试执行', false, error.message);
  }
  
  // 生成测试报告
  return generateTestReport();
}

// 运行测试
if (require.main === module) {
  runTests().then(success => {
    process.exit(success ? 0 : 1);
  }).catch(error => {
    console.error('💥 测试失败:', error);
    process.exit(1);
  });
}

module.exports = { runTests, testResults };
